Red Hat Enterprise Linux Implementation

Bash Script Creation

Module Topics

Bash Shell Scripting Basics
Creating Bash Shell Scripts
Executing Bash Shell Scripts
Displaying Output
Using Variables
Using Bash Shell Expansion Features
Iterating With the for Loop
Troubleshooting Shell Script Bugs

Bash Shell Scripting Basics

Simple system administration tasks can be accomplished with Linux command-line tools
More complex tasks require chaining multiple commands
- Command line tools can be combined with Bash shell to create powerful shell scripts
Bash shell script is executable file composed of list of commands
- Can be further leveraged by other scripts
Proficiency in shell scripting is essential to Linux system administration
- Especially crucial in enterprise environments
- Shell scripts can improve efficiency and accuracy of routine tasks

Transcript:

Many simple day-to-day system administration tasks can be accomplished by the numerous Linux command-line tools available to administrators. However, tasks with greater complexity often require the chaining together of multiple commands. In these situations, Linux command-line tools can be combined with the offerings of the Bash shell to create powerful shell scripts to solve real-world problems.

In its simplest form, a Bash shell script is simply an executable file composed of a list of commands. However, when well-written, a shell script can itself become a powerful command-line tool when executed on its own, and can even be further leveraged by other scripts.

Proficiency in shell scripting is essential to the success of Linux system administrators in all operational environments. Working knowledge of shell scripting is especially crucial in enterprise environments, where its use can translate to improved efficiency and accuracy of routine task completion.

Bash Shell Scripting Basics

Choosing a Programming Language

Bash shell scripting not right tool for all scenarios
Programming languages have strengths and weaknesses; none is right for every situation
Bash scripts are good for tasks that can be accomplished mainly by calling other command line utilities
- If task involves heavy data processing and manipulation, languages such as Perl or Python are better
Bash supports arithmetic operations limited to simple integer arithmetic
- For more complex arithmetic operations, consider C or C++
Bash supports 1D and associative arrays, but Perl and Python have better array functionality
Gain experience with shell scripting and programming languages to learn advantages and disadvantages of each

Transcript:

While Bash shell scripting can be used to accomplish many tasks, it may not be the right tool for all scenarios. Administrators have a wide variety of programming languages at their disposal, such as C, C++, Perl, Python, Ruby and other programming languages. Each programming language has its strengths and weaknesses, and as such, none of the programming languages are the right tool for every situation.

Bash shell scripts are a good choice for tasks which can be accomplished mainly by calling other command-line utilities. If the task involves heavy data processing and manipulation, other languages such as Perl or Python will be better suited for the job. While Bash supports arithmetic operations, they are limited to simple integer arithmetic. For more complex arithmetic operations, C or C++ should be considered. If a solution requires the use of arrays. Bash is probably not the best tool. Bash has supported one-dimensional arrays for some time, and the latest version even supports associative arrays. However, Perl or Python have much better array functionality, with the ability to accommodate multidimensional arrays. As administrators become proficient at shell scripting, they will gain more knowledge regarding its capabilities and limitations. This experience combined with exposure to other programming languages over time, will provide administrators with a better understanding of the advantages and disadvantages of each, and which problems each one is best suited for.

Creating Bash Shell Scripts

Create Bash shell script by opening new file in any text editor
Advanced editors such as vim or emacs understand Bash shell syntax and provide color-coded highlighting
Highlighting is helpful for spotting syntax errors like unpaired quotes and unclosed brackets

Command Interpreter

First line of Bash shell script begins with 2-byte notation #!
- Commonly referred to as a "sharp-bang" or "sha-bang"
- Technically referred to as "magic pattern"
#! indicates that file is executable shell script
Path name follows to command interpreter that executes script
Bash scripts are interpreted by Bash shell and so begin with:
```
#!/bin/bash
```

Transcript:

A Bash shell script can be created by opening a new empty file in a text editor. While any text editor can be used, advanced editors, such as vim or emacs, understand Bash shell syntax and can provide color-coded highlighting. This highlighting can be a tremendous help for spotting syntactical errors, such as unpaired quotes, unclosed brackets, and other common blunders.

The first line of a Bash shell script begins with #!, also commonly referred to as a sharp-bang, or the abbreviated version, sha-bang. This two-byte notation is technically referred to as the magic pattern. It indicates that the file is an executable shell script. The path name that follows is the command interpreter, the program that should be used to execute the script. Since Bash shell scripts are to be interpreted by the Bash shell, they begin with the following first line.

Executing Bash Shell Scripts

Use chmod and possibly chown to change script file permissions and ownership so script is executable
- Grant execute permission only to users script is intended for
Executable script can be invoked by name on command line
If only base name of script file is entered, Bash searches directories in shell PATH variable for first executable file matching name
- Avoid script names that match other executable files
- Configure PATH variable correctly so script is first match

To display directory script resides in, use which

[student@server1 ~]$ which hello
~/bin/hello

[student@server1 ~]$ echo $PATH
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/student/.local/bin:/home/student/bin

Transcript:

After a Bash shell script is written, its file permissions and ownership need to be modified so that it is executable. Execute permission is modified with the chmod command, possibly in conjunction with the chown command to change the file ownership of the script accordingly. Execute permission should only be granted to the users that the script is intended for.

Once a Bash shell script is executable, it can be invoked by entering its name on the command line. If only the base name of the script file is entered, Bash will search through the directories specified in the shell’s PATH environmental variable, looking for the first instance of an executable file matching that name. Administrators should avoid script names that match other executable files, and should also ensure that the PATH variable is correctly configured on their system so that the script will be the first match found by the shell. The which command, followed by the file-name of the executeable script displays in which directory the script resides that is executed when the script name is invoked as a command resides.

Displaying Output

Using echo

Use echo to display arbitrary text by passing text as argument to echo
By default, text is directed to STDOUT (standard out)

Can be redirected to STDERR (standard error)

Example: Use echo to display "Hello, world" to STDOUT

[student@server1 ~]$ cat hello
#!/bin/bash

echo "Hello, world"

[student@server1 ~]$ ./hello
Hello, world

Use echo in shell scripts to display information or error messages during script execution
- Helpful indicator of script progress
- Can be directed to STDOUT or STDERR or redirected to log file

Displaying Output

Good practice to direct errors to STDERR to differentiate error messages from status messages

[student@server1 ~]$ cat hello
#!/bin/bash

echo "Hello, world"
echo "ERROR: Houston, we have a problem." >&2

[student@server1 ~]$ ./hello 2> hello.log
Hello, world

[student@server1 ~]$ cat hello.log
ERROR: Houston, we have a problem.

echo is useful for script debugging
Add echo statements to misbehaving part of script to clarify commands being executed and values of variables invoked

Displaying Output

Quoting Special Characters

Some characters and words have special meanings to Bash shell
Some situations require literal values rather than the special meanings of these characters
- Example: # is interpreted by Bash as beginning of comment and is therefore ignored along with everything following on same line
  If "comment" meaning is not desired, then Bash needs to know that # is to be treated as a literal value
To disable meaning of special characters and words, use escape character, \, single quotes, '', or double quotes, ""

\ removes special meaning of single character immediately following

[student@server1 ~]$ echo # not a comment

[student@server1 ~]$ echo \# not a comment
# not a comment

Displaying Output

To escape more than one character, use \ multiple times or use ''

Single quotes preserve literal meaning of all characters they enclose

[student@server1 ~]$ echo # not a comment #

[student@server1 ~]$ echo \# not a comment #
# not a comment

[student@server1 ~]$ echo \# not a comment \#
# not a comment #

[student@server1 ~]$ echo '# not a comment #'
# not a comment #

Displaying Output

Double quotes are like single quotes but do not preserve literal value of dollar sign ($), back-ticks (`) and backslash (\)

The special meaning of \ is retained only when it precedes a dollar sign ($), back-tick (`), double quote ("), backslash (\), or newline

[student@server1 ~]$ echo '$HOME'
$HOME

[student@server1 ~]$ echo '`pwd`'
`pwd`

[student@server1 ~]$ echo '"Hello, world"'
"Hello, world"

[student@server1 ~]$ echo "$HOME"
/home/student

[student@server1 ~]$ echo "`pwd`"
/home/student

[student@server1 ~]$ echo ""Hello, world""
Hello, world

[student@server1 ~]$ echo "\$HOME"
$HOME

[student@server1 ~]$ echo "\`pwd\`"
`pwd`

[student@server1 ~]$ echo "\"Hello, world\""
"Hello, world"

Using Variables

Useful in complex scripts
Serve as containers in which shell script stores data
Stored data easy to access and modify during script execution

Assigning Values to Variables

To assign value to variable, use this syntax:
```
VARIABLENAME=value
```
Variable names are typically uppercase letters
- Can also be numbers, lowercase letters, and underscore character, _
- Cannot start with number
Use = without spaces to assign values
- Example: Valid variables
  COUNT=40 first_name=John file1=/tmp/abc _ID=RH123

Using Variables

Integer and string values commonly stored in variables
Good practice to quote string values when assigning to variables
- Space character is interpreted by Bash as word separator when not enclosed in single or double quotes
Use of single or double quotes depends on how special characters should be treated
```
full_name='John Doe'
full_name="$FIRST $LAST"
price='$1'
```

Using Variables

Expanding Variable Values

To recall value of variable, precede variable name with $
- Process known as variable expansion
Value of VARIABLENAME can be referenced with $VARIABLENAME
- $VARIABLENAME syntax is simplified version of ${VARIABLENAME}

There are situations where brace-quoted form must be used

[student@server1 ~]$ FIRST_=Jane

[student@server1 ~]$ FIRST=John

[student@server1 ~]$ LAST=Doe

[student@server1 ~]$ echo $FIRST_$LAST
JaneDoe

[student@server1 ~]$ echo ${FIRST}_$LAST
John_Doe

Transcript:

The value of a variable can be recalled through a process known as variable expansion by preceding the variable name with a dollar sign, $. For example, the value of the VARIABLENAME variable can be referenced with $VARIABLENAME. The $VARIABLENAME syntax is the simplified version of the brace-quoted form of variable expansion, ${VARIABLENAME}. While the simplified form is usually acceptable, there are situations where the brace-quoted form must be used to remove ambiguity and avoid unexpected results.

In the following example, without the use of brace quotes, Bash will interpret $FIRST_$LAST as the variable $FIRST_ followed by the variable $LAST, rather than the variables $FIRST and $LAST separated by the _ character. Therefore, brace quoting must be used for variable expansion to function properly in this scenario.

Using Bash Shell Expansion Features

Command Substitution

Replaces invocation of command with output of its execution
- Allows output to be used in new context such as argument to another command, value of variable, and for loop construct (covered later)
Can be invoked by enclosing command in back-ticks: `<COMMAND>`

Preferred method is newer $() syntax: $(<COMMAND>)

[student@server1 ~]$ echo "Current time: `date`"
Current time is Thu Jun  5 16:24:24 EDT 2014.

[student@server1 ~]$ echo "Current time: $(date)"
Current time is Thu Jun  5 16:24:30 EDT 2014.

Using Bash Shell Expansion Features

Newer syntax preferred because it allows nesting command substitutions

Example: Use output of find as arguments for tar and store that output in variable TAROUTPUT

[root@server1 ~]# TAROUTPUT=$(tar cvf /tmp/incremental_backup.tar $(find /etc -type f -mtime -1))

[root@server1 ~]# echo $TAROUTPUT
/etc/group /etc/gshadow /etc/shadow- /etc/passwd /etc/shadow /etc/passwd- /etc/tuned/active_profile /etc/rht /etc/group- /etc/gshadow- /etc/resolv.conf

Using Bash Shell Expansion Features

Arithmetic Expansion

Use to perform simple integer arithmetic operations
Syntax is $[<EXPRESSION>]
Arithmetic expressions enclosed within $[] are replaced with results
Before evaluation, Bash performs variable expansion and command substitution

Nesting of arithmetic substitutions is allowed

[student@server1 ~]$ echo $[1+1]
2

[student@server1 ~]$ echo $[2*2]
4

[student@server1 ~]$ COUNT=1; echo $[$[$COUNT+1]*2]
4

Using Bash Shell Expansion Features

Space characters are allowed

Can improve readability in complicated expressions and when variables are used

[student@server1 ~]$ SEC_PER_MIN=60

[student@server1 ~]$ MIN_PER_HR=60

[student@server1 ~]$ HR_PER_DAY=24

[student@server1 ~]$ SEC_PER_DAY=$[ $SEC_PER_MIN * $MIN_PER_HR * $HR_PER_DAY ]

[student@server1 ~]$ echo "There are $SEC_PER_DAY seconds in a day."
There are 86400 seconds in a day.

Using Bash Shell Expansion Features

Operator

Meaning

<VARIABLE>++

Variable post-increment

<VARIABLE>--

Variable post-decrement

++<VARIABLE>

Variable pre-increment

--<VARIABLE>

Variable pre-decrement

Unary minus

Unary plus

Exponentiation

Multiplication

Division

Remainder

Addition

Subtraction

Using Bash Shell Expansion Features

Multiple operators evaluated according to precedence

To change evaluation order from default, use parentheses to group sub-expressions

[student@server1 ~]$ echo $[ 1 + 1 * 2]
3

[student@server1 ~]$ echo $[ (1 +1) * 2 ]
4

Order of precedence from highest to lowest, with equal operators listed together

Operator

Meaning

<VARIABLE>++, <VARIABLE>--

Variable post-increment and post-decrement

++<VARIABLE>, --<VARIABLE>

Variable pre-increment and pre-decrement

Unary minus and plus

Exponentiation

*, /, %

Multiplication, division, remainder

+, -

Addition, subtraction

Iterating With the `for` Loop

Repetitive task can take form of action executed multiple times on single target
- Example: Checking every minute for 10 minutes to see if process has completed
Can also take form of action executed single time on multiple targets
- Example: Backing up each database on system
for loop is shell looping construct used for task iterations
```
for <VARIABLE> in <LIST>; do
     <COMMAND>
     ...
     <COMMAND> referencing <VARIABLE>
done
```
- Loop processes <LIST> items in order and exits
- Each list item stored as value of <VARIABLE> while loop executes <COMMAND>
  - Naming of variable is arbitrary
  - <VARIABLE> value is typically referenced by <COMMAND>

Transcript:

System administrators often encounter repetitive tasks in their day-to-day activities. Repetitive tasks can take the form of executing an action multiple times on an target, such as checking a process every minute for 10 minutes to see if it has completed. Task repetition can also take the form of executing an action a single time across multiple targets, such as performing a database backup of each database on a system. The for loop is one of the multiple shell looping constructs offered by Bash, and can be used for task iterations.

Bash’s for-loop construct uses the following syntax. The loop processes the items provided in <LIST> in order one by one and exits after processing the last item on the list. Each item in the list is temporarily stored as the value of <VARIABLE>, while the for loop executes the block of commands contained in its construct. The naming of the variable is arbitrary. Typically, the variable value is referenced by commands in the command block.

Iterating with the `for` Loop

Can enter for loop items directly

Can generate for loop items from shell expansions, such as variable substitution

Example: Different ways that lists can be provided to for loops

[student@server1 ~]$ for HOST in host1 host2 host3; do echo $HOST; done
host1
host2
host3

[student@server1 ~]$ for HOST in host{1,2,3}; do echo $HOST; done
host1
host2
host3

[student@server1 ~]$ for HOST in host{1..3}; do echo $HOST; done
host1
host2
host3

[student@server1 ~]$ for FILE in file*; do ls $FILE; done
filea
fileb
filec

[student@server1 ~]$ for FILE in file{a..c}; do ls $FILE; done
filea
fileb
filec

[student@server1 ~]$ for PACKAGE in $(rpm -qa | grep kernel); do echo "$PACKAGE was installed on $(date -d @$(rpm -q --qf "%{INSTALLTIME}\n" $PACKAGE))"; done
abrt-addon-kerneloops-2.1.11-12.el7.x86_64 was installed on Tue Apr 22 00:09:07 EDT 2014
kernel-3.10.0-121.el7.x86_64 was installed on Thu Apr 10 15:27:52 EDT 2014
kernel-tools-3.10.0-121.el7.x86_64 was installed on Thu Apr 10 15:28:01 EDT 2014
kernel-tools-libs-3.10.0-121.el7.x86_64 was installed on Thu Apr 10 15:26:22 EDT 2014

[student@server1 ~]$ for EVEN in $(seq 2 2 8); do echo "$EVEN"; done; echo "Who do we appreciate?"

2
4
6
8
Who do we appreciate?

Troubleshooting Shell Script Bugs

Typically due to typographical errors, syntactical errors, and poor logic
Easiest way to prevent is to catch them during authoring
Use text editor with syntactical highlighting
Develop good script-authoring practices and adhere to them

Commenting Scripts

Use comments at beginning of script to explain script purpose, intended actions, and general logic
Use comments throughout script to clarify important or complex sections
- Comments help when debugging and serve as reminders of script mechanics after time has passed

Transcript:

Inevitably, administrators who write, use, or maintain shell scripts will encounter bugs with a script. Bugs are typically due to typographical errors, syntactical errors, or poor script logic.

A good way to deal with shell scripting bugs is to make a concerted effort to prevent them from occurring in the first place during the authoring of the script. As previously mentioned, using a text editor with Bash syntactical highlighting can help make mistakes more obvious when writing scripts. Another easy way to avoid introducing bugs into scripts is by adhering to good practices during the creation of the script.

Use comments to help clarify to readers the purpose and logic of the script. The top of every script should include comments providing an overview of the script’s purpose, intended actions, and general logic. Also use comments throughout the script to clarify the key portions, and especially sections that may cause confusion. Comments will not only aid other users in the reading and debugging of the script, but will also often help the author recall the workings of the script once some time has passed.

Troubleshooting Shell Script Bugs

Format to Improve Readability

As long as syntax is correct, command interpreter executes commands without regard for structure and formatting
Break long commands into multiple lines of smaller code chunks
- Easier to read and comprehend
Align beginning and end of multiline statements to show where control structures begin and end
- Easier to see if statement is closed properly
Indent lines with multiline statements to represent hierarchy of code logic and flow of control structures
Use line spacing to separate command blocks to clarify beginning and end of code sections
Be consistent with formatting throughout script

Transcript:

Structure the contents of the script to improve readability. As long as the syntax is correct, the command interpreter will flawlessly execute the commands within a script with absolutely no regard for their structure or formatting. Here are some good practices to follow:

Break up long commands into multiple lines of smaller code chunks. Shorter pieces of code are much easier for readers to digest and comprehend.
Line up the beginning and ending of multiline statements to make it easier to see that control structures begin and end, and whether they are being closed properly.
Indent lines with multiline statements to represent the hierarchy of code logic and the flow of control structures.
Use line spacing to separate command blocks to clarify when one code section ends and another begins.
Use consistent formatting through the entirety of a script.

Troubleshooting Shell Script Bugs

Before

#!/bin/bash
for PACKAGE in $(rpm -qa | grep kernel); do echo "$PACKAGE was installed on $(date -d @$(rpm -q --qf "%{INSTALLTIME}\n" $PACKAGE))"; done

After

#!/bin/bash
#
# This script queries the RPM database to get information about when
# kernel-related packages were installed on a system.
#

# Variables
PACKAGETYPE=kernel
PACKAGES=$(rpm -qa | grep $PACKAGETYPE)

# Loop through packages
for PACKAGE in $PACKAGES; do
     # Determine package install date and time
     INSTALLEPOCH=$(rpm -q --qf "%{INSTALLTIME}\n" $PACKAGE)

     # RPM reports time in epoch, so need to convert
     # it to date and time format with date command
     INSTALLDATETIME=$(date -d @$INSTALLEPOCH)

     # Print message
     echo "$PACKAGE was installed on $INSTALLDATETIME"
done

Troubleshooting Shell Script Bugs

Assumptions

Do not make assumptions about integrity of inputs such as command-line arguments, user input, command substitutions, variable expansions, and file name expansions
- Use proper quoting and sanity checking
Do not make assumptions about actions external to script such as interacting with files and calling external commands
- Use Bash file and directory tests
- Perform error checking on exit status of commands
Ruling out assumptions can keep script from failing
Example: Lines of code that make risky assumptions
```
cd $TMPDIR
rm *
```
- If directory change fails, file removal is performed on list of unknown files in unintended directory!

Transcript:

Do not make assumptions regarding the outcome of actions taken by a script. This is especially true of inputs to the script, such as command-line arguments, input from users, command substitutions, variable expansions, and file name expansions. Rather than making assumptions about the integrity of these inputs, make the worthwhile effort to employ the use of proper quoting and sanity checking.

The same caution should be utilized when acting upon entities external to the script. This includes interacting with files, and calling external commands. Make use of Bash’s vast number of file and directory tests when interacting with files and directories. Perform error checking on the exit status of commands rather than counting on their success and blindly continuing along with the script when an unexpected error occurs.

The extra steps taken to rule out assumptions will increase the script’s robustness, and keep it from being easily derailed and then inflicting unintended and unnecessary damage to a system.

A couple of seemingly harmless lines of code, such as the ones that follow, make very risky assumptions about command execution outcome and file name expansion. If the directory change fails, either due to directory permissions or the directory being nonexistent, the subsequent file removal will be performed on a list of unknown files in an unintended directory.

Troubleshooting Shell Script Bugs

Modifying Someone Else’s Script

Not everyone agrees on what good practices are
It is important to apply guidelines consistently
Be aware of individual differences in programming styles and script formatting
When modifying another’s script, follow structure, formatting, and practices used by author
- Imposing your style may make script inconsistent and reduce its readability and maintainability

Troubleshooting Shell Script Bugs

Debug Mode

To activate debug mode, add -x to command interpreter in first line of script
```
#!/bin/bash -x
```
Another way is to execute script as argument to Bash with -x
```
[student@server1 bin]$ bash -x <SCRIPTNAME>
```
Debug mode prints script commands and shell expansions before executing

Troubleshooting Shell Script Bugs

[student@server1 bin]$ cat filesize
#!/bin/bash

DIR=/home/student/tmp

for FILE in $DIR/*; do
    echo "File $FILE is $(stat --printf='%s' $FILE) bytes."
done

[student@server1 bin]$ ./filesize
File /home/student/tmp/filea is 133 bytes.
File /home/student/tmp/fileb is 266 bytes.
File /home/student/tmp/filec is 399 bytes.

[student@server1 bin]$ bash -x ./filesize
+ DIR=/home/student/tmp
+ for FILE in '$DIR/*'
++ stat --printf=%s /home/student/tmp/filea
+ echo 'File /home/student/tmp/filea is 133 bytes.'
File /home/student/tmp/filea is 133 bytes.
+ for FILE in '$DIR/*'
++ stat --printf=%s /home/student/tmp/fileb
+ echo 'File /home/student/tmp/fileb is 266 bytes.'
File /home/student/tmp/fileb is 266 bytes.
+ for FILE in '$DIR/*'
++ stat --printf=%s /home/student/tmp/filec
+ echo 'File /home/student/tmp/filec is 399 bytes.'
File /home/student/tmp/filec is 399 bytes.

Troubleshooting Shell Script Bugs

Large output of debug mode may hinder troubleshooting long scripts
Debug mode can be enabled for only part of script
Useful when source of problem is narrowed down to portion of script
To turned debugging on/off at specific points in script, use set -x and set +x

Troubleshooting Shell Script Bugs

This example shows previous example script with debugging enabled only for command line enclosed in for loop

[student@server1 bin]$ cat filesize
#!/bin/bash

DIR=/home/student/tmp

for FILE in $DIR/*; do
        set -x
        echo "File $FILE is $(stat --printf='%s' $FILE) bytes."
        set +x
done

[student@server1 bin]$ ./filesize
++ stat --printf=%s /home/student/tmp/filea
+ echo 'File /home/student/tmp/filea is 133 bytes.'
File /home/student/tmp/filea is 133 bytes.
+ set +x
++ stat --printf=%s /home/student/tmp/fileb
+ echo 'File /home/student/tmp/fileb is 266 bytes.'
File /home/student/tmp/fileb is 266 bytes.
+ set +x
++ stat --printf=%s /home/student/tmp/filec
+ echo 'File /home/student/tmp/filec is 399 bytes.'
File /home/student/tmp/filec is 399 bytes.
+ set +x

Troubleshooting Shell Script Bugs

To invoke verbose mode, use -v
Bash prints each command to STDOUT prior to execution

To turn verbose mode on and off at specific points in script, use set -v and set +v

[student@server1 bin]$ cat filesize
#!/bin/bash

DIR=/home/student/tmp

for FILE in $DIR/*; do
    echo "File $FILE is $(stat --printf='%s' $FILE) bytes."
done

[student@server1 bin]$ bash -v ./filesize
stat --printf='%s' $FILE) bytes."
stat --printf='%s' $FILE) bytes.
stat --printf='%s' $FILE
File /home/student/tmp/filea is 133 bytes.
stat --printf='%s' $FILE) bytes."
stat --printf='%s' $FILE) bytes.
stat --printf='%s' $FILE
File /home/student/tmp/fileb is 266 bytes.
stat --printf='%s' $FILE) bytes."
stat --printf='%s' $FILE) bytes.
stat --printf='%s' $FILE
File /home/student/tmp/filec is 399 bytes.

References

Man pages: bash(1), magic(5), echo(1), echo(1p), and seq(1)

Summary

Bash Shell Scripting Basics
Creating Bash Shell Scripts
Executing Bash Shell Scripts
Displaying Output
Using Variables
Using Bash Shell Expansion Features
Iterating With the for Loop
Troubleshooting Shell Script Bugs

Module Completion

Nice job!

Click the button below to complete this module of the course:

Red Hat Enterprise Linux Implementation

Bash Script Creation

Module Topics

Bash Shell Scripting Basics

Bash Shell Scripting Basics

Creating Bash Shell Scripts

Executing Bash Shell Scripts

Displaying Output

Displaying Output

Displaying Output

Displaying Output

Displaying Output

Using Variables

Using Variables

Using Variables

Using Bash Shell Expansion Features

Using Bash Shell Expansion Features

Using Bash Shell Expansion Features

Using Bash Shell Expansion Features

Using Bash Shell Expansion Features

Using Bash Shell Expansion Features

Iterating With the for Loop

Iterating with the for Loop

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Troubleshooting Shell Script Bugs

Summary

Module Completion

Iterating With the `for` Loop

Iterating with the `for` Loop